package E.哈希表;

import java.util.*;

public class _剑指Offer50_第一个只出现一次的字符 {
    public static void main(String[] args) {
        _剑指Offer50_第一个只出现一次的字符 test = new _剑指Offer50_第一个只出现一次的字符();
        System.out.println(test.firstUniqChar("aadadaad"));;
    }
    /**
     * 自解：
     * 思路1：利用hashset 先全部放入 如果包含了就删除 最后遍历set 如果空了就返回空
     * ---如果是奇数情况不行
     * 思路2：利用hashmap key是char value是boolean true代表目前是一个 只要存在第二个就是false 后面判断是false就不管
     * ---存char 默认会排序 所以返回的话成了按字符顺序排序
     * 更改：key存int
     * --- 那就不能合并同类想了
     * @param s
     * @return
     */

    public char firstUniqChar(String s) {
        if (s == null){
            return ' ';
        }

        Map<Character,Boolean> map = new LinkedHashMap<>();
        char[] chars = s.toCharArray();
        for (char ch: chars){
            if (map.containsKey(ch)){
                if (map.get(ch) == true){
                    map.put(ch,false);
                }
            }else {
                map.put(ch,true);
            }
        }

        if (map.containsValue(true)){
            for (char c: map.keySet()){
                if (map.get(c) == true){
                    return (char)(c);
                }
            }
        }
        return ' ';

        //题解推荐解法：
        /*
          Map<Character, Boolean> dic = new LinkedHashMap<>();
        char[] sc = s.toCharArray();
        for(char c : sc)
            dic.put(c, !dic.containsKey(c));
        for(Map.Entry<Character, Boolean> d : dic.entrySet()){
           if(d.getValue()) return d.getKey();
        }
        return ' ';

         */

    }

    /**\
     * 放弃
     * 思路3：暴力双指针--如果遇到相等的就设为true 不便利后面 这样后面前指针到这个元素又会当做新的
     */
    public char firstUniqChar1(String s){
        if (s.length()==0 ){
            return ' ';
        }else if(s.length()==1){

            return s.charAt(0);
        }
        char[] chars = s.toCharArray();

      //  int i=0,j=i+1;

        for (int i=0;i<s.length()-1;i++){
            boolean flag = false;
            for (int j=i+1;j<s.length();j++){
                if (chars[i]==chars[j]){
                    flag =true;
                    chars[j] = 0;
                }
            }
            //true 存在相同的
            if (!flag){
                return chars[i];
            }
            while (chars[i+1] == 0){
                i++;
            }
            i--;
        }

        if (chars != null &&chars[chars.length-1] != 0){
            return chars[chars.length-1];
        }

        return ' ';
    }

}
